home *** CD-ROM | disk | FTP | other *** search
/ Network CD 2 / Network CD - Volume 2.iso / programs / internet / tcp / amitcp / amitcp-src-22.lha / AmiTCP-2.2 / src / util / inetd / inetd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-20  |  42.7 KB  |  1,710 lines
  1. RCS_ID_C="$Id: inetd.c,v 1.11 1993/10/21 01:51:20 ppessi Exp $";
  2. /*
  3.  * inetd.c --- Internet super-server
  4.  *
  5.  * Author: ppessi <Pekka.Pessi@hut.fi>
  6.  *
  7.  * Copyright © 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
  8.  *                  Helsinki University of Technology, Finland.
  9.  *                  All rights reserved.
  10.  *
  11.  * Created      : Mon May 24 00:34:11 1993 ppessi
  12.  * Last modified: Thu Oct 21 03:51:03 1993 ppessi
  13.  *
  14.  * $Log: inetd.c,v $
  15.  * Revision 1.11  1993/10/21  01:51:20  ppessi
  16.  * Added correcto prototype for CheckIO()
  17.  *
  18.  * Revision 1.10  1993/10/20  05:31:07  ppessi
  19.  * Using now gettimeofday().
  20.  *
  21.  * Revision 1.9  1993/08/13  04:57:07  jraja
  22.  * Fixes for the second release.
  23.  *
  24.  * Revision 1.8  1993/08/10  20:46:23  jraja
  25.  * Added version string.
  26.  *
  27.  * Revision 1.7  1993/08/10  20:29:26  jraja
  28.  *  Added leap years to the time calculations (ppessi).
  29.  *
  30.  * Revision 1.6  1993/06/20  12:40:17  jraja
  31.  * Added SAVEDS to the start_builtin for it to be able to find SysBase.
  32.  *
  33.  * Revision 1.5  1993/06/04  11:44:19  jraja
  34.  * Fixes for the first release.
  35.  *
  36.  * Revision 1.4  93/06/03  20:11:51  ppessi
  37.  * Changed the daemon naming scheme, removed template from inetd.conf
  38.  * 
  39.  * Revision 1.3  93/05/28  20:11:48  ppessi
  40.  * Now works with CreateNewProc
  41.  * 
  42.  * Revision 1.2  93/05/25  23:07:35  ppessi
  43.  * Added external daemon launching
  44.  * 
  45.  * Revision 1.1  93/05/24  21:42:36  ppessi
  46.  * Original BSD code.
  47.  *
  48.  */
  49.  
  50. #include "inetd_rev.h"
  51. static const char version[] = VERSTAG;
  52.  
  53. char copyright[] =
  54. "@(#) Copyright © 1983 The Regents of the University of California.\n"
  55.                       "All rights reserved.\n"
  56.      "Copyright © 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>\n"
  57.                       "Helsinki University of Technology, Finland.\n"
  58.                       "All rights reserved.\n";
  59.  
  60. /*
  61.  * Copyright (c) 1983,1991 The Regents of the University of California.
  62.  * All rights reserved.
  63.  *
  64.  * Redistribution and use in source and binary forms, with or without
  65.  * modification, are permitted provided that the following conditions
  66.  * are met:
  67.  * 1. Redistributions of source code must retain the above copyright
  68.  *    notice, this list of conditions and the following disclaimer.
  69.  * 2. Redistributions in binary form must reproduce the above copyright
  70.  *    notice, this list of conditions and the following disclaimer in the
  71.  *    documentation and/or other materials provided with the distribution.
  72.  * 3. All advertising materials mentioning features or use of this software
  73.  *    must display the following acknowledgement:
  74.  *    This product includes software developed by the University of
  75.  *    California, Berkeley and its contributors.
  76.  * 4. Neither the name of the University nor the names of its contributors
  77.  *    may be used to endorse or promote products derived from this software
  78.  *    without specific prior written permission.
  79.  *
  80.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  81.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  82.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  83.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  84.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  85.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  86.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  87.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  88.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  89.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  90.  * SUCH DAMAGE.
  91.  */
  92.  
  93. /****** netutil.doc/inetd ***************************************************
  94. *
  95. *  NAME
  96. *        inetd - internet ``super-server''
  97. *
  98. *  TEMPLATE
  99. *       inetd DEBUG/S CONFIGFILE
  100. *
  101. *  DESCRIPTION
  102. *
  103. *       Inetd should be run when the AmiTCP/IP protocol stack is started.
  104. *       Inetd listens for connections on certain internet sockets.  When a
  105. *       connection is found on one of its sockets, it decides what service the
  106. *       socket corresponds to, and invokes a program to service the request.
  107. *       After the program is finished, it continues to listen on the socket
  108. *       (except in some cases which will be described below).  Essentially,
  109. *       inetd allows running one daemon to invoke several others, reducing
  110. *       load on the system.
  111. *
  112. *  PARAMETERS
  113. *       DEBUG      Turns on debugging.
  114. *
  115. *       CONFIGFILE Specifies the configuration file name.
  116. *
  117. *  CONFIGURATION
  118. *
  119. *       Upon execution, inetd reads its configuration information from a
  120. *       configuration file which, by default, is AmiTCP:db/inetd.conf. There
  121. *       must be an entry for each field of the configuration file, with
  122. *       entries for each field separated by a tab or a space.  Comments are
  123. *       denoted by a ``#'' at the beginning of a line or ``;'' anywhere in the
  124. *       line. There must be an entry for each field. The fields of the
  125. *       configuration file are as follows:
  126. *
  127. *             service name
  128. *             socket type
  129. *             protocol
  130. *             wait/nowait
  131. *             user
  132. *             server program
  133. *             server program name
  134. *             server program arguments
  135. *
  136. *       The service-name entry is the name of a valid service in the
  137. *       netdatabase.  For ``internal'' services (discussed below), the service
  138. *       name must be the official name of the service.
  139. *
  140. *       The socket-type should be one of ``stream'', ``dgram'', ``raw'',
  141. *       ``rdm'', or ``seqpacket'', depending on whether the socket is a
  142. *       stream, datagram, raw, reliably delivered message, or sequenced packet
  143. *       socket. Current system supports only stream, datagram and raw
  144. *       protocols.
  145. *
  146. *       The protocol must be a valid protocol as given in netdatabase.
  147. *       Examples might be ``tcp'' or ``udp''.
  148. *
  149. *       The wait/nowait entry is useful for datagram sockets only (other
  150. *       sockets should have a ``nowait'' entry in this space).  If a datagram
  151. *       server connects to its peer, freeing the socket so inetd can received
  152. *       further messages on the socket, it is said to be a ``multi-threaded''
  153. *       server, and should use the ``nowait'' entry.  For datagram servers
  154. *       which process all incoming datagrams on a socket and eventually time
  155. *       out, the server is said to be ``single-threaded'' and should use a
  156. *       ``wait'' entry.  Comsat and talkd are both examples of the latter type
  157. *       of datagram server.
  158. *
  159. *       The user entry should contain the user name of the user as whom the
  160. *       server should run. This field is for Unix and future compability
  161. *       only.
  162. *
  163. *       The server-program entry should contain the pathname of the program
  164. *       which is to be executed by inetd when a request is found on its
  165. *       socket.  If the server program is resident, the path name should be
  166. *       suppressed. If inetd provides this service internally, this entry
  167. *       should be ``internal''.
  168. *
  169. *       The server-program-name is CLI command name for the server process. It
  170. *       is shown in the printout of ``status'' command. (Task name of the
  171. *       server process is the service and the peer address, e.g. ``echo
  172. *       [192.233.15.19]''.) This and argument entry are optional.
  173. *
  174. *       The server program arguments should be just as arguments normally are.
  175. *
  176. *       Inetd provides several ``trivial'' services internally by use of
  177. *       routines within itself.  These services are ``echo'', ``discard'',
  178. *       ``chargen'' (character generator), ``daytime'' (human readable time),
  179. *       and ``time'' (machine readable time, in the form of the number of
  180. *       seconds since mid­ night, January 1, 1900).  All of these services are
  181. *       TCP and UDP based.  For details of these services, consult the
  182. *       appropriate RFC from the Network Information Center.
  183. *
  184. *       Inetd rereads its configuration file when it receives the CTRL-F
  185. *       signal.  Services may be added, deleted or modified when the
  186. *       configuration file is reread.
  187. *
  188. *  HISTORY
  189. *       The inetd command appeared in 4.3BSD system.
  190. *
  191. *  SEE ALSO
  192. *
  193. *****************************************************************************
  194. *
  195. */
  196.  
  197. /*
  198.  * Inetd - Internet super-server
  199.  *
  200.  * This program invokes all internet services as needed.
  201.  * connection-oriented services are invoked each time a connection is
  202.  * made, by creating a process. Created server process is passed the
  203.  * connection as file descriptor 0 and is expected to do a getpeername
  204.  * to find out the source host and port.
  205.  *
  206.  * Datagram oriented services are invoked when a datagram arrives; a
  207.  * process is created and passed a pending message on file descriptor
  208.  * 0. Datagram servers may either connect to their peer, freeing up
  209.  * the original socket for inetd to receive further messages on, or
  210.  * ``take over the socket'', processing all arriving datagrams and,
  211.  * eventually, timing out. The first type of server is said to
  212.  * be ``multi-threaded''; the second type of server
  213.  * ``single-threaded''.
  214.  *
  215.  * Inetd uses a configuration file which is read at startup and,
  216.  * possibly, at some later time in response to a signal CTRL_F.  The
  217.  * configuration file is parsed with standard DOS functions with
  218.  * template given below. Multiple line entries must have a ``+'' char at
  219.  * the end of the file.
  220.  *
  221.  *     service             must be in /etc/services
  222.  *    socket type            stream/dgram/raw/rdm/seqpacket
  223.  *    protocol            must be in /etc/protocols
  224.  *    dowait                    single-threaded/multi-threaded
  225.  *    user                user to run daemon as
  226.  *    server program            full path name
  227.  *    server program name        CLI command name (optional)
  228.  *    server program arguments    Normal command argument line 
  229.  *
  230.  * Comment lines are indicated by a `#' in column 1. 
  231.  */
  232.  
  233. #include <sys/param.h>
  234. #include <sys/stat.h>
  235. #include <sys/ioctl.h>
  236. #include <sys/socket.h>
  237. #include <sys/time.h>
  238.  
  239. #include <netinet/in.h>
  240. #include <arpa/inet.h>
  241.  
  242. #include <errno.h>
  243. #include <signal.h>
  244. #include <netdb.h>
  245. #include <stdio.h>
  246. #include <string.h>
  247. #include <stdlib.h>
  248. #include <time.h>
  249.  
  250. #ifdef AMIGA
  251. #include <exec/execbase.h>
  252. #include <exec/memory.h>
  253. #include <devices/timer.h>
  254. #include <dos/dostags.h>
  255. extern struct ExecBase *SysBase;
  256. #if __SASC
  257. #include <proto/socket.h>
  258. #include <proto/dos.h>
  259. #include <clib/exec_protos.h>
  260. #include <pragmas/exec_sysbase_pragmas.h>
  261. #include <pragmas/timer_pragmas.h>
  262. /* #elif __GNUC__
  263. #include <inline/socket.h>
  264. #include <inline/exec.h>
  265. */
  266. #else 
  267. #error Unsupported compiler
  268. #include <clib/socket_protos.h>
  269. #endif
  270. #include <sys/syslog.h>
  271. /* Correct prototype for the CheckIO.
  272.  * (The one in clib/exec_protos.h has wrong return value type: BOOL (16 bits) 
  273.  * instead of a pointer (32 bits)!)
  274.  */
  275. struct IORequest * CheckIO(struct IORequest *req);
  276. #else /* def AMIGA */
  277. #include <pwd.h>
  278. #include <sys/file.h>
  279. #include <sys/wait.h>
  280. #include <sys/resource.h>
  281. #include <syslog.h>
  282. #endif
  283.  
  284. /* Compiler specific definitions */
  285. #if __GNUC__
  286. #define SAVEDS
  287. #define REG(X)
  288. #define ASM
  289. #elif __SASC
  290. #define SAVEDS __saveds
  291. #define REG(X) register __ ## X
  292. #define ASM    __asm
  293. #else
  294. #define SAVEDS
  295. #endif
  296.  
  297. #include "inetd.h"
  298. #include "inetdlib.h"
  299.  
  300. /* don't start more than TOOMANY servers in CNT_INTVL seconds */
  301. #define    TOOMANY        10
  302. #define    CNT_INTVL    60        
  303.  
  304. #define    RETRYTIME    (60*10)        /* retry after bind or server fail */
  305.  
  306. #define INETDNAME "inetd"
  307.  
  308. #define MAXARGS 9
  309. enum fileargs 
  310. { 
  311.   service = 0, socket_type, protocol, wait, user, server, cmdname, arguments
  312. };
  313. #define TYPETEMPLATE "stream,dgram,raw,rdm,seqpacket"
  314. #define WAITTEMPLATE "nowait,wait"
  315.  
  316. extern    int errno;
  317.  
  318. void reapchild(void);
  319. void startserver(register struct servtab *sep, long ctrl);
  320. void askalarm(long seconds);
  321. void getalarm(void);
  322. void config(void);
  323. void retry(void);
  324. void setup(register struct servtab *sep);
  325. struct servtab *enter(struct servtab *cp);
  326.  
  327. int setconfig(void);
  328. struct servtab *getconfigent(void);
  329. void freeconfig(register struct servtab *cp);
  330. void endconfig(void);
  331. void print_service(char *action, struct servtab *sep);
  332.  
  333. ASM VOID exitcode(REG(d0) LONG status, REG(d1) LONG exitmessage);
  334. LONG start_builtin(void);
  335. void setproctitle(char *a, int s);
  336.  
  337. UBYTE *proctitle(char *a, int s);
  338. void  amigainit(void);
  339. void amigadeinit(void);
  340. static ULONG csprintf(struct CSource *buf, const char *fmt, ...);
  341.  
  342. int    nsock = 0, maxsock = 0;
  343. fd_set    allsock;
  344. int    options = 0;
  345. struct    servent *sp = NULL;
  346.  
  347. /* 
  348.  * We create a "process table" for builtins, because they 
  349.  * must be waited as they use the same code segment as we do 
  350.  */
  351. #define MAX_BUILTIN_PROC 16
  352. int builtins_started = 0;
  353. long ptable[MAX_BUILTIN_PROC] = { 0 };
  354.  
  355. struct DaemonPort *dport = NULL;
  356.  
  357. #define DO_WAIT   ((struct DaemonMessage *)1)
  358. #define DONT_WAIT ((struct DaemonMessage *)NULL)
  359.  
  360. struct MsgPort *tport = NULL;
  361. struct timerequest *tmsg = NULL;
  362. int   timer_is_open = 0;
  363. #define TimerBase (tmsg->tr_node.io_Device)
  364.  
  365. struct    servtab {
  366.     char    *se_service;        /* name of service */
  367.     long    se_socktype;        /* type of socket to use */
  368.     char    *se_proto;        /* protocol used */
  369.     struct     DaemonMessage *se_wait; /* single threaded server */
  370.     char    *se_user;        /* user name to run as */
  371.     struct    biltin *se_bi;        /* if built-in, description */
  372.     char    *se_server;        /* server program */
  373.     char    *se_argv0;            /* cli name for daemon */
  374.     char    *se_argv;            /* program arguments */
  375.     long    se_fd;            /* open descriptor */
  376.     struct    sockaddr_in se_ctrladdr;/* bound address */
  377.     struct    timeval se_time;    /* start of se_count */
  378.     struct    servtab *se_next;
  379.     short    se_checked;        /* looked at during merge */
  380.     short    se_count;        /* number started since se_time */
  381. } *servtab;
  382.  
  383. /* 
  384.  * Internal Services 
  385.  *
  386.  * Because Data Segment is *not* duplicated by CreateNewProc 
  387.  * server routines must be re-entrable and not touch global data
  388.  */ 
  389. int echo_stream(void *SocketBase, int s, struct servtab *sep);
  390. int echo_dg(void *SocketBase, int s, struct servtab *sep);
  391. int discard_stream(void *SocketBase, int s, struct servtab *sep);
  392. int discard_dg(void *SocketBase, int s, struct servtab *sep); 
  393. int machtime_stream(void *SocketBase, int s, struct servtab *sep);
  394. int machtime_dg(void *SocketBase, int s, struct servtab *sep); 
  395. int daytime_stream(void *SocketBase, int s, struct servtab *sep);
  396. int daytime_dg(void *SocketBase, int s, struct servtab *sep);
  397. int chargen_stream(void *SocketBase, int s, struct servtab *sep);
  398. int chargen_dg(void *SocketBase, int s, struct servtab *sep);
  399.  
  400. struct biltin {
  401.     char    *bi_service;        /* internally provided service name */
  402.     int    bi_socktype;        /* type of socket supported */
  403.     int    bi_process;        /* 1 if should start a process */
  404.     struct    DaemonMessage *bi_wait;    /* DO_WAIT if should wait for child */
  405.     int    (*bi_fn)(void *SocketBase, int s, struct servtab *sep);
  406.                         /* function which performs it */
  407. } biltins[] = {
  408.     /* Echo received data */
  409.     "echo",        SOCK_STREAM,    1, DONT_WAIT,    echo_stream,
  410.     "echo",        SOCK_DGRAM,    0, DONT_WAIT,    echo_dg,
  411.  
  412.     /* Internet /dev/null */
  413.     "discard",    SOCK_STREAM,    1, DONT_WAIT,    discard_stream,
  414.     "discard",    SOCK_DGRAM,    0, DONT_WAIT,    discard_dg,
  415.  
  416.     /* Return 32 bit time since 1970 */
  417.     "time",        SOCK_STREAM,    0, DONT_WAIT,    machtime_stream,
  418.     "time",        SOCK_DGRAM,    0, DONT_WAIT,    machtime_dg,
  419.  
  420.     /* Return human-readable time */
  421.     "daytime",    SOCK_STREAM,    0, DONT_WAIT,    daytime_stream,
  422.     "daytime",    SOCK_DGRAM,    0, DONT_WAIT,    daytime_dg,
  423.  
  424.     /* Familiar character generator */
  425.     "chargen",    SOCK_STREAM,    1, DONT_WAIT,    chargen_stream,
  426.     "chargen",    SOCK_DGRAM,    0, DONT_WAIT,    chargen_dg,
  427.     0
  428. };
  429.  
  430. /* Internal buffer size. Allocated from stack */
  431. #define    BUFSIZE    8192
  432.  
  433. #define NUMINT    (sizeof(intab) / sizeof(struct inent))
  434.  
  435. int debug;
  436. char *CONFIG = _PATH_INETDCONF;
  437.  
  438. main(void)
  439. {
  440.   register struct servtab *sep;
  441.   ULONG events;
  442.   ULONG mask;
  443.  
  444.   {
  445.     LONG Argv[2];
  446.     struct RDArgs *rdargs;
  447.  
  448.     Argv[0] = Argv[1] = 0;
  449.     rdargs = ReadArgs("DEBUG/S,CONFIGFILE", Argv, NULL);
  450.  
  451.     if (!rdargs) {
  452.       PrintFault(IoErr(), "ReadArgs");
  453.       exit(1);
  454.     }
  455.     debug = Argv[0];
  456.     if (Argv[1])
  457.       CONFIG = strdup((char *)Argv[1]);
  458.  
  459.     FreeArgs(rdargs);
  460.   }
  461.  
  462.   if (debug) {
  463.     options |= SO_DEBUG;
  464.   } else {
  465. #if 0
  466.     daemon(0, 0);
  467. #endif
  468.   }
  469. #ifdef notyet
  470.   openlog("inetd", LOG_PID | LOG_NOWAIT, LOG_DAEMON);
  471. #endif
  472.  
  473.   amigainit();
  474.  
  475.   events = 1 << (dport->dp_Port.mp_SigBit) | 1 << (tport->mp_SigBit) 
  476.     | SIGBREAKF_CTRL_F | SIGBREAKF_CTRL_C;
  477.   SetSocketSignals(0L, 0L, 0L); /* no no no no no no there is no EINTR */
  478.  
  479.   config();
  480.  
  481.   for (;;) {
  482.     int n, ctrl;
  483.     fd_set readable;
  484.  
  485.     mask = events;
  486.     readable = allsock;
  487.     if ((n = WaitSelect(maxsock + 1, &readable, (fd_set *)NULL,
  488.             (fd_set *)NULL, (struct timeval *)NULL, &mask)) < 0) {
  489.       if (errno != EINTR)
  490.     syslog(LOG_WARNING, "select: %s", strerror(errno));
  491.       continue;
  492.     }
  493.  
  494.     if (mask & SIGBREAKF_CTRL_F) {
  495.       config();
  496.     }
  497.  
  498.     if (mask & SIGBREAKF_CTRL_C) {
  499.       exit(0);
  500.     }
  501.  
  502.     if (mask & (1<<(tport->mp_SigBit))) {
  503.       getalarm();
  504.     }
  505.  
  506.     if (mask & (1<<(dport->dp_Port.mp_SigBit))) {
  507.       reapchild();
  508.     }
  509.  
  510.     for (sep = servtab; n && sep; sep = sep->se_next)
  511.       if (sep->se_fd != -1 && FD_ISSET(sep->se_fd, &readable)) {
  512.     n--;
  513.     if (debug)
  514.       fprintf(stderr, "someone wants %s\n", sep->se_service);
  515.     if (sep->se_socktype == SOCK_STREAM) {
  516.       ctrl = accept(sep->se_fd, NULL, NULL);
  517.       if (debug)
  518.         fprintf(stderr, "accept, ctrl %ld\n", ctrl);
  519.       if (ctrl < 0) {
  520.         if (errno != EINTR)
  521.           syslog(LOG_WARNING, "accept (for %s): %s", 
  522.              sep->se_service, strerror(errno));
  523.         continue;
  524.       }
  525.     } else
  526.       ctrl = sep->se_fd;
  527.     if (sep->se_bi == 0 || sep->se_bi->bi_process) {
  528.       startserver(sep, ctrl);
  529.     } else {
  530.       (*sep->se_bi->bi_fn)(SocketBase, ctrl, sep);
  531.       if (sep->se_socktype == SOCK_STREAM)
  532.         CloseSocket(ctrl);
  533.     }
  534.       }
  535.   }
  536. }
  537.  
  538. /*
  539.  * startserver:
  540.  *      Launch a new process to handle service
  541.  */
  542. void 
  543. startserver( register struct servtab *sep, long ctrl)
  544. {
  545.   LONG id;
  546.   struct DaemonMessage *dm = CreateIORequest(dport, sizeof(*dm));
  547.   UBYTE *dname = proctitle(sep->se_service, ctrl);
  548.   int ok = 0;
  549.  
  550.   if (!dm || !dname) { 
  551.     syslog(LOG_ERR, "inetd exhausted memory, exits");
  552.     if (dm) DeleteIORequest(dm);
  553.     if (dname) FreeVec(dname);
  554.     exit(1);
  555.   }
  556.  
  557.   if (sep->se_count++ == 0) {
  558.     (void)gettimeofday(&sep->se_time, (struct timezone *)0);
  559.   } else if (sep->se_count >= TOOMANY) {
  560.     struct timeval now;
  561.     (void)gettimeofday(&now, (struct timezone *)0);
  562.     if (now.tv_sec - sep->se_time.tv_sec > CNT_INTVL) {
  563.       sep->se_time = now;
  564.       sep->se_count = 1;
  565.     } else {
  566.       syslog(LOG_ERR, "%s/%s server failing (looping), "
  567.          "service terminated\n", sep->se_service, sep->se_proto);
  568.       FD_CLR(sep->se_fd, &allsock);
  569.       (void) CloseSocket(sep->se_fd);
  570.       sep->se_fd = -1;
  571.       sep->se_count = 0;
  572.       nsock--;
  573.       askalarm(RETRYTIME);
  574.     }
  575.   }
  576.  
  577.   if (sep->se_socktype == SOCK_STREAM)
  578.     id = ReleaseSocket(ctrl, -1);
  579.   else
  580.     id = ReleaseCopyOfSocket(ctrl, -1);
  581.  
  582.   if (dm != NULL && id != -1) {
  583.     dm->dm_Msg.mn_Node.ln_Name = dname;
  584.     dm->dm_Id = id;
  585.     dm->dm_Family = AF_INET;
  586.     dm->dm_Type = sep->se_socktype;
  587.  
  588.     if (sep->se_bi) {
  589.       struct Process *pid = NULL;
  590.       /* 
  591.        * Start a built in function
  592.        */
  593.       dm->dm_Retval = (LONG)sep;
  594.       dm->dm_Type = DMTYPE_INTERNAL;
  595.       if (builtins_started < MAX_BUILTIN_PROC) {
  596.     pid =
  597.       CreateNewProcTags(NP_Entry, start_builtin, NP_StackSize, BUFSIZE*2,
  598.                 NP_ExitCode, exitcode, NP_ExitData, dm,
  599.                 NP_Priority, -10,
  600.                 dname ? NP_Name : TAG_DONE, dname,
  601.                 TAG_DONE);
  602.     ok = pid != NULL;
  603.     if (ok) {
  604.       dm->dm_Pid = pid; 
  605.       ptable[builtins_started++] = (long)pid;
  606.     }
  607.       }
  608.     } else {
  609.       /*
  610.        * Start an external process
  611.        */
  612.       BPTR input = Open("NIL:", MODE_OLDFILE);
  613.       BPTR output = Open("NIL:", MODE_OLDFILE);
  614. #if 1
  615.       BPTR seglist;
  616.       struct Segment *sl;
  617.  
  618.       /* Try to find seglist from resident list */
  619.       Forbid();
  620.       if (sl = FindSegment(sep->se_server, NULL, FALSE)) {
  621.     if (sl->seg_UC >= 0) {
  622.       sl->seg_UC++;
  623.       dm->dm_Seg = sl;        /* must be freed */
  624.     } else if (sl->seg_UC != -2) {
  625.       sl = NULL;
  626.     }
  627.       }
  628.       Permit();
  629.  
  630.       if (sl)
  631.     seglist = sl->seg_Seg;
  632.       else
  633.     seglist = NewLoadSegTags(sep->se_server, TAG_DONE);
  634.  
  635.       if (input && output && seglist) {
  636.     ok = (int)
  637.       CreateNewProcTags(NP_Seglist, seglist,
  638.                 NP_FreeSeglist, sl == NULL,
  639.                 NP_Cli, TRUE, 
  640.                 NP_CommandName, sep->se_argv0,
  641.                 NP_Arguments, sep->se_argv, 
  642.                 NP_Input, input, 
  643.                 NP_Output, output,
  644.                 NP_StackSize, BUFSIZE*2, 
  645.                 NP_Priority, -10, 
  646.                 NP_ExitCode, dport->dp_ExitCode,
  647.                 NP_ExitData, dm, 
  648.                 dname ? NP_Name : TAG_END, dname,
  649.                 TAG_END, NULL);
  650.       }
  651.       if (!ok) {
  652.     if (seglist) UnLoadSeg(seglist);
  653.     if (input) Close(input);
  654.     if (output) Close(output);
  655.       }
  656.     }
  657. #else
  658.       if (input && output) {
  659.     ok = !SystemTags(sep->se_argv,
  660.              SYS_Asynch, 1, SYS_UserShell, 1,
  661.              SYS_Input, input, SYS_Output, output,
  662.              NP_StackSize, BUFSIZE*2,
  663.              NP_ExitCode, exitcode, NP_ExitData, dm,
  664.              NP_Priority, -10, 
  665.              dname ? NP_Name : TAG_END, dname,
  666.              TAG_END, NULL);
  667.       }
  668.       if (!ok) {
  669.     if (input) Close(input);
  670.     if (output) Close(output);
  671.       }
  672.     }
  673. #endif
  674.     if (ok && sep->se_wait) {
  675.       sep->se_wait = dm;
  676.       if (sep->se_fd >= 0) {
  677.     FD_CLR(sep->se_fd, &allsock);
  678.     nsock--;
  679.       }
  680.     }
  681.   }
  682.  
  683.   /* Clean up */
  684.   if (!ok) {
  685.     /* Drop the pending datagram */
  686.     char buf[32];
  687.     if (sep->se_socktype != SOCK_STREAM)
  688.       recv(ctrl, buf, sizeof (buf), 0);
  689.  
  690.     if (dm) DeleteIORequest(dm);
  691.     if (dname) FreeVec(dname);
  692.     if (id != -1) {
  693.       ctrl = ObtainSocket(id, AF_INET, sep->se_socktype, 0);
  694.       if (ctrl >= 0) CloseSocket(ctrl);
  695.     }
  696.   }
  697. }
  698.  
  699. /*
  700.  * reapchild: 
  701.  *      handle death messages from childs
  702.  */
  703. void
  704. reapchild(void)
  705. {
  706.   struct DaemonMessage *dm;
  707.  
  708.   while (dm = (struct DaemonMessage *)GetMsg(dport)) {
  709.     long status = dm->dm_Retval;
  710.     register struct servtab *sep;
  711.  
  712.     if (debug)
  713.       fprintf(stderr, "reaped child %s\n", dm->dm_Msg.mn_Node.ln_Name);
  714.     for (sep = servtab; sep; sep = sep->se_next)
  715.       if (sep->se_wait == dm) {
  716.     if (status)
  717.       syslog(LOG_WARNING,
  718.          "%s: exit status 0x%lx",
  719.          sep->se_server, status);
  720.     if (debug)
  721.       fprintf(stderr, "restored %s, fd %ld\n",
  722.           sep->se_service, sep->se_fd);
  723.     FD_SET(sep->se_fd, &allsock);
  724.     nsock++;
  725.     sep->se_wait = DO_WAIT;
  726.       }
  727.  
  728.     /* update "process table" */ 
  729.     if (dm->dm_Type == DMTYPE_INTERNAL) {
  730.       long pid = (long)dm->dm_Pid;
  731.       int i = --builtins_started;
  732.       for (i; i >= 0; i--) 
  733.     if (pid = ptable[i]) {
  734.       ptable[i] = ptable[builtins_started];
  735.       break;
  736.     }
  737.       if (i < 0) {
  738.     syslog(LOG_ALERT, "inetd: unknown internal daemon 0x%lx", pid);
  739.     builtins_started++;
  740.       }
  741.     }
  742.     /* Free resources allocated for the daemon */
  743.     if (dm->dm_Seg) {
  744.       Forbid();
  745.       dm->dm_Seg->seg_UC--;
  746.       Permit();
  747.     }
  748.     if (dm->dm_Msg.mn_Node.ln_Name)
  749.       FreeVec(dm->dm_Msg.mn_Node.ln_Name);
  750.     DeleteIORequest(dm);
  751.   }
  752. }
  753.  
  754. /*
  755.  * config:
  756.  *      configure services
  757.  */
  758. void
  759. config(void)
  760. {
  761.   register struct servtab *sep, *cp, **sepp;
  762.  
  763.   if (!setconfig()) {
  764.     endconfig();
  765.     return;
  766.   }
  767.  
  768.   for (sep = servtab; sep; sep = sep->se_next)
  769.     sep->se_checked = 0;
  770.   while (cp = getconfigent()) {
  771.     for (sep = servtab; sep; sep = sep->se_next)
  772.       if (strcmp(sep->se_service, cp->se_service) == 0 &&
  773.       strcmp(sep->se_proto, cp->se_proto) == 0)
  774.     break;
  775.     if (sep != 0) {
  776.       freeconfig(sep);
  777.       /*
  778.        * sep->se_wait may be holding the "pid" of a daemon
  779.        * that we're waiting for.  If so, don't overwrite
  780.        * it unless the config file explicitly says don't 
  781.        * wait.
  782.        */
  783.       if (cp->se_bi == 0 && 
  784.       (sep->se_wait == DO_WAIT || cp->se_wait == DONT_WAIT))
  785.     sep->se_wait  = cp->se_wait;
  786.       sep->se_service = cp->se_service;
  787.       sep->se_proto   = cp->se_proto;
  788.       sep->se_user    = cp->se_user;
  789.       sep->se_server  = cp->se_server;
  790.       sep->se_argv    = cp->se_argv;
  791.       if (debug)
  792.     print_service("REDO", sep);
  793.     } else {
  794.       sep = enter(cp);
  795.       if (debug)
  796.     print_service("ADD ", sep);
  797.     }
  798.     sep->se_checked = 1;
  799.     sp = getservbyname(sep->se_service, sep->se_proto);
  800.     if (sp == 0) {
  801.       syslog(LOG_ERR, "%s/%s: unknown service",
  802.          sep->se_service, sep->se_proto);
  803.       if (sep->se_fd != -1)
  804.     (void) CloseSocket(sep->se_fd);
  805.       sep->se_fd = -1;
  806.       continue;
  807.     }
  808.     if (sp->s_port != sep->se_ctrladdr.sin_port) {
  809.       sep->se_ctrladdr.sin_port = sp->s_port;
  810.       if (sep->se_fd != -1)
  811.     (void) CloseSocket(sep->se_fd);
  812.       sep->se_fd = -1;
  813.     }
  814.     if (sep->se_fd == -1)
  815.       setup(sep);
  816.   }
  817.   endconfig();
  818.   /*
  819.    * Purge anything not looked at above.
  820.    */
  821.   sepp = &servtab;
  822.   while (sep = *sepp) {
  823.     if (sep->se_checked) {
  824.       sepp = &sep->se_next;
  825.       continue;
  826.     }
  827.     *sepp = sep->se_next;
  828.     if (sep->se_fd != -1) {
  829.       FD_CLR(sep->se_fd, &allsock);
  830.       nsock--;
  831.       (void) CloseSocket(sep->se_fd);
  832.     }
  833.     if (debug)
  834.       print_service("FREE", sep);
  835.     freeconfig(sep);
  836.     free((char *)sep);
  837.   }
  838. }
  839.  
  840. /*
  841.  * askalarm:
  842.  *      ask for timeout
  843.  */
  844. void 
  845. askalarm(long seconds) 
  846. {
  847.   if (tmsg->tr_node.io_Message.mn_Node.ln_Type == NT_UNKNOWN 
  848.       || CheckIO(tmsg)) {
  849.     tmsg->tr_time.tv_secs = seconds;
  850.     tmsg->tr_time.tv_micro = 0;
  851.     SendIO(tmsg);
  852.   }
  853. }
  854.  
  855. /*
  856.  * getalarm:
  857.  *      handle timeouts
  858.  */
  859. void 
  860. getalarm(void) 
  861. {
  862.   struct Message *msg;
  863.   while (msg = GetMsg(tport)) {
  864.     if ((struct timerequest *)msg == tmsg) {
  865.       tmsg->tr_node.io_Message.mn_Node.ln_Type = NT_UNKNOWN; 
  866.       retry();
  867.       continue;
  868.     }
  869.   }
  870. }
  871.  
  872. /*
  873.  * retry:
  874.  *      try to setup all configured services
  875.  */
  876. void
  877. retry(void)
  878. {
  879.   register struct servtab *sep;
  880.  
  881.   for (sep = servtab; sep; sep = sep->se_next)
  882.     if (sep->se_fd == -1)
  883.       setup(sep);
  884. }
  885.  
  886. /*
  887.  * setup:
  888.  *      open a socket for given port
  889.  */
  890. void
  891. setup(register struct servtab *sep)
  892. {
  893.   int on = 1;
  894.  
  895.   if ((sep->se_fd = socket(AF_INET, sep->se_socktype, 0)) < 0) {
  896.     syslog(LOG_ERR, "%s/%s: socket: %s",
  897.        sep->se_service, sep->se_proto, strerror(errno));
  898.     return;
  899.   }
  900. #define    turnon(fd, opt) \
  901.   setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on))
  902.     if (strcmp(sep->se_proto, "tcp") == 0 && (options & SO_DEBUG) &&
  903.     turnon(sep->se_fd, SO_DEBUG) < 0)
  904.       syslog(LOG_ERR, "setsockopt (SO_DEBUG): %s", strerror(errno));
  905.   if (turnon(sep->se_fd, SO_REUSEADDR) < 0)
  906.     syslog(LOG_ERR, "setsockopt (SO_REUSEADDR): %s", strerror(errno));
  907. #undef turnon
  908.   if (bind(sep->se_fd, (struct sockaddr *)&sep->se_ctrladdr,
  909.        sizeof (sep->se_ctrladdr)) < 0) {
  910.     syslog(LOG_ERR, "%s/%s: bind: %s",
  911.        sep->se_service, sep->se_proto, strerror(errno));
  912.     (void) CloseSocket(sep->se_fd);
  913.     sep->se_fd = -1;
  914.     askalarm(RETRYTIME);
  915.     return;
  916.   }
  917.   if (sep->se_socktype == SOCK_STREAM)
  918.     listen(sep->se_fd, 10);
  919.   FD_SET(sep->se_fd, &allsock);
  920.   nsock++;
  921.   if (sep->se_fd > maxsock)
  922.     maxsock = sep->se_fd;
  923. }
  924.  
  925. /*
  926.  * enter:
  927.  *      Allocate a new server entry
  928.  */ 
  929. struct servtab *
  930. enter(struct servtab *cp)
  931. {
  932.   register struct servtab *sep;
  933.  
  934.   sep = (struct servtab *)malloc(sizeof (*sep));
  935.   if (sep == (struct servtab *)0) {
  936.     syslog(LOG_ERR, "Out of memory.");
  937.     exit(20);
  938.   }
  939.   *sep = *cp;
  940.   sep->se_fd = -1;
  941.   sep->se_next = servtab;
  942.   servtab = sep;
  943.  
  944.   return (sep);
  945. }
  946.  
  947. /*
  948.  * print_service:
  949.  *    Dump relevant information to stderr
  950.  */
  951. void
  952. print_service(char *action, struct servtab *sep)
  953. {
  954.   fprintf(stderr, "%s: %s proto=%s, "
  955.       "wait=%ld, user=%s builtin=0x%lx server=%s\n",
  956.       action, sep->se_service, sep->se_proto,
  957.       sep->se_wait, sep->se_user, (int)sep->se_bi, sep->se_server);
  958. }
  959.  
  960.  
  961. /* 
  962.  * Functions to read configuration file
  963.  */
  964.  
  965. BPTR    fconfig = NULL;
  966. long    linecnt = 0;
  967. struct    servtab serv;
  968. #define LINEBUFLEN 1024
  969. char    *linbuf = NULL;
  970. struct  CSource    line = { 0, 0, 0 };
  971. struct RDArgs *largs = NULL;
  972.  
  973. void logdoserror(const char *banner);
  974. struct CSource * nextline(BPTR fh);
  975.  
  976. int
  977. setconfig(void)
  978. {
  979.   linecnt = 0;
  980.  
  981.   if (!linbuf) 
  982.     linbuf = malloc(LINEBUFLEN);
  983.  
  984.   if (!largs) 
  985.     largs = AllocDosObject(DOS_RDARGS, NULL);
  986.  
  987.   if (fconfig != NULL) {
  988.     Seek(fconfig, 0L, OFFSET_BEGINNING);
  989.   } else {
  990.     fconfig = Open(CONFIG, MODE_OLDFILE);
  991.     if (!fconfig) logdoserror("setconfig");
  992.   }
  993.   return (fconfig != NULL && linbuf != NULL && largs != NULL);
  994. }
  995.  
  996. void
  997. endconfig(void)
  998. {
  999.   if (fconfig) {
  1000.     (void) Close(fconfig);
  1001.     fconfig = NULL;
  1002.   }
  1003. #if 0
  1004.   if (linbuf) {
  1005.     free(linbuf);
  1006.     linbuf = NULL;
  1007.   }
  1008. #endif
  1009.   if (largs) {
  1010.     FreeDosObject(DOS_RDARGS, largs);
  1011.     largs = NULL;
  1012.   }
  1013. }
  1014.  
  1015. struct servtab *
  1016. getconfigent(void)
  1017. {
  1018.   register struct servtab *sep = &serv;
  1019.   struct CSource *cp;
  1020.  
  1021.  more:
  1022.   while ((cp = nextline(fconfig)) && 
  1023.      (cp->CS_Buffer[0] == '#' || cp->CS_Buffer[0] == ';'))
  1024.     ;
  1025.   if (cp == NULL)
  1026.     return NULL;
  1027.  
  1028.   {
  1029.     short len, i, item;
  1030.     char *old, *new; 
  1031.     UBYTE *argv[MAXARGS];
  1032.     UBYTE argbuf[LINEBUFLEN];
  1033.  
  1034.     /* Parse line */
  1035.     for (len = i = 0; i < MAXARGS - 1; i++) {
  1036.       argv[i] = argbuf + len;
  1037.       item = (short)ReadItem(argbuf + len, sizeof(argbuf) - len, cp);
  1038.       if (item < 0) {
  1039.     logdoserror("ReadItem");
  1040.     return NULL;
  1041.       } else if (item == ITEM_NOTHING) {
  1042.     for (; i < MAXARGS; i++) {
  1043.       argv[i] = " ";
  1044.       len += 2;
  1045.     }
  1046.       } else {
  1047.     len += strlen(argv[i]) + 1;
  1048.       }
  1049.     }
  1050.     if (i == MAXARGS - 1) {
  1051.       argv[i] = cp->CS_Buffer + cp->CS_CurChr;
  1052.       len += strlen(argv[i]) + 1;
  1053.     }
  1054.  
  1055.     sep->se_socktype = FindArg(TYPETEMPLATE, (STRPTR)argv[socket_type]) + 1;
  1056.     if (sep->se_socktype == 0) 
  1057.       sep->se_socktype = DMTYPE_UNKNOWN;
  1058.  
  1059.     switch (FindArg(WAITTEMPLATE, (STRPTR)argv[wait])) {
  1060.     case -1:
  1061.       /* A error message might be cool */
  1062.     case 0:
  1063.       sep->se_wait = DONT_WAIT;
  1064.       break;
  1065.     case 1:
  1066.       sep->se_wait = DO_WAIT;
  1067.       break;
  1068.     }
  1069.  
  1070.     new = malloc(len);
  1071.     if (!new) {
  1072.       SetIoErr(ERROR_NO_FREE_STORE);
  1073.       logdoserror("getconfigent");
  1074.       return NULL;
  1075.     }
  1076.  
  1077.     sep->se_service = new; 
  1078.     old = (char *)argv[service]; while (*new++ = *old++); 
  1079.     sep->se_proto = new;
  1080.     old = (char *)argv[protocol]; while (*new++ = *old++); 
  1081.     sep->se_user = new;
  1082.     old = (char *)argv[user]; while (*new++ = *old++); 
  1083.     sep->se_server = new;
  1084.     old = (char *)argv[server]; while (*new++ = *old++); 
  1085.     sep->se_argv0 = new;
  1086.     old = (char *)argv[cmdname]; while (*new++ = *old++); 
  1087.     sep->se_argv = new;
  1088.     old = (char *)argv[arguments]; while (*new++ = *old++); 
  1089.     /* An empty command line can cause a guru with SASC startup code */
  1090.     if (sep->se_argv[0] == '\0')
  1091.       sep->se_argv = " ";
  1092.   } 
  1093.   
  1094.   if (strcmp(sep->se_server, "internal") == 0) {
  1095.     register struct biltin *bi;
  1096.  
  1097.     for (bi = biltins; bi->bi_service; bi++)
  1098.       if (bi->bi_socktype == sep->se_socktype &&
  1099.       strcmp(bi->bi_service, sep->se_service) == 0)
  1100.     break;
  1101.     if (bi->bi_service == 0) {
  1102.       syslog(LOG_ERR, "inetd: internal service %s unknown\n", sep->se_service);
  1103.       free(sep->se_service);
  1104.       goto more;
  1105.     }
  1106.     sep->se_bi = bi;
  1107.     sep->se_wait = bi->bi_wait;
  1108.   } else
  1109.     sep->se_bi = NULL;
  1110.  
  1111.   return (sep);
  1112. }
  1113.  
  1114. void
  1115. freeconfig(register struct servtab *cp)
  1116. {
  1117.   if (cp->se_service)
  1118.     free(cp->se_service);
  1119. }
  1120.  
  1121. /*
  1122.  * nextline
  1123.  *      get a CSource string containing next line
  1124.  */
  1125. struct CSource *
  1126. nextline(BPTR fh)
  1127. {
  1128.   size_t len = line.CS_Length = 0;
  1129.   UBYTE *buffer = line.CS_Buffer = linbuf;
  1130.   
  1131.   line.CS_CurChr = 0;
  1132.   
  1133.   for (;;) {
  1134.     linecnt++;
  1135.     if (FGets(fh, buffer + len, LINEBUFLEN - len - 1) == NULL) {
  1136.       if (IoErr()) {
  1137.     logdoserror("nextline");
  1138.     return NULL;
  1139.       }
  1140.       if (len == 0)
  1141.     return NULL;
  1142.     }
  1143.  
  1144.     len += strlen(buffer + len);
  1145.     line.CS_Length = len;
  1146.  
  1147.     /* a long line ? */
  1148.     if (len == LINEBUFLEN - 1 && buffer[LINEBUFLEN - 2] != '\n') {
  1149.       if (buffer[0] != '#') {
  1150.     SetIoErr(ERROR_LINE_TOO_LONG);
  1151.     logdoserror("nextline");
  1152.     return NULL;
  1153.       } else {
  1154.     /* A kludge for LONG comment lines */
  1155.     len = 1;
  1156.     linecnt--;
  1157.     continue;
  1158.       }
  1159.     }
  1160.  
  1161.     /* Check for a continued line */
  1162.     if (len > 1 && buffer[len - 2] != '+') {
  1163.       return &line;
  1164.     } else {
  1165.       /* current line continues */
  1166.       if (len > 2)
  1167.     len -= 2;
  1168.       else 
  1169.     len = 0;
  1170.     }
  1171.   }
  1172. }
  1173.  
  1174. /* 
  1175.  * logdoserror
  1176.  *     add the last DOS error into AmiTCP/IP log
  1177.  */
  1178. void 
  1179. logdoserror(const char *banner)
  1180. {
  1181.   LONG code = IoErr();
  1182.  
  1183.   if (linbuf && Fault(code, (UBYTE *)banner, linbuf, LINEBUFLEN)) {
  1184.     syslog(LOG_ERR, "inetd %s at line %ld\n", linbuf, linecnt);
  1185.   } else {
  1186.     syslog(LOG_ERR, "inetd %s: unknown DOS error %ld at line %ld\n", 
  1187.        code, linecnt);
  1188.   }
  1189. }
  1190.  
  1191.  
  1192. /*
  1193.  * Internet services provided internally by inetd:
  1194.  */
  1195.  
  1196. /* Echo service -- echo data back */
  1197. int
  1198. echo_stream(void *SocketBase, int s, struct servtab *sep)
  1199. {
  1200.   char buffer[BUFSIZE];
  1201.   int i;
  1202.  
  1203.   while ((i = recv(s, buffer, sizeof(buffer), 0)) > 0 &&
  1204.      send(s, buffer, i, 0) > 0)
  1205.     ;
  1206.   return 0;
  1207. }
  1208.  
  1209. /* Echo service -- echo data back */
  1210. int
  1211. echo_dg(void *SocketBase, int s, struct servtab *sep)
  1212. {
  1213.   char buffer[BUFSIZE];
  1214.   long i, size;
  1215.   struct sockaddr sa;
  1216.  
  1217.   size = sizeof(sa);
  1218.   if ((i = recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size)) < 0)
  1219.     return 0;
  1220.   (void) sendto(s, buffer, i, 0, &sa, sizeof(sa));
  1221.  
  1222.   return 0;
  1223. }
  1224.  
  1225. /* Discard service -- ignore data */
  1226. int
  1227. discard_stream(void *SocketBase, int s, struct servtab *sep)
  1228. {
  1229.   char buffer[BUFSIZE];
  1230.  
  1231.   while (recv(s, buffer, sizeof(buffer), 0) > 0)
  1232.     ;
  1233.  
  1234.   return 0;
  1235. }
  1236.  
  1237.  
  1238. /* Discard service -- ignore data */
  1239. int
  1240. discard_dg(void *SocketBase, int s, struct servtab *sep)
  1241. {
  1242.   char buffer[BUFSIZE];
  1243.  
  1244.   (void) recv(s, buffer, sizeof(buffer), 0);
  1245.   
  1246.   return 0;
  1247. }
  1248.  
  1249. #include <ctype.h>
  1250. #define LINESIZ 72
  1251. char ring[128];
  1252. char *endring = NULL;
  1253.  
  1254. void
  1255. initring(void)
  1256. {
  1257.   register int i;
  1258.  
  1259.   endring = ring;
  1260.  
  1261.   for (i = 0; i <= 128; ++i)
  1262.     if (isprint(i))
  1263.       *endring++ = i;
  1264. }
  1265.  
  1266. /* Character generator */
  1267. chargen_stream(void *SocketBase, int s, struct servtab *sep)
  1268. {
  1269.   register char *rs;
  1270.   long len;
  1271.   char text[LINESIZ+2];
  1272.  
  1273.   if (!endring) {
  1274.     initring();
  1275.     rs = ring;
  1276.   }
  1277.  
  1278.   text[LINESIZ] = '\r';
  1279.   text[LINESIZ + 1] = '\n';
  1280.   for (rs = ring;;) {
  1281.     if ((len = endring - rs) >= LINESIZ)
  1282.       bcopy(rs, text, LINESIZ);
  1283.     else {
  1284.       bcopy(rs, text, len);
  1285.       bcopy(ring, text + len, LINESIZ - len);
  1286.     }
  1287.     if (++rs == endring)
  1288.       rs = ring;
  1289.     if (send(s, text, sizeof(text), 0) != sizeof(text))
  1290.       break;
  1291.   }
  1292.  
  1293.   return 0;
  1294. }
  1295.  
  1296. /* Character generator */
  1297. chargen_dg(void *SocketBase, int s, struct servtab *sep)
  1298. {
  1299.   struct sockaddr sa;
  1300.   static char *rs;
  1301.   long len, size;
  1302.   char text[LINESIZ+2];
  1303.  
  1304.   if (endring == 0) {
  1305.     initring();
  1306.     rs = ring;
  1307.   }
  1308.  
  1309.   size = sizeof(sa);
  1310.   if (recvfrom(s, text, sizeof(text), 0, &sa, &size) < 0)
  1311.     return 0;
  1312.  
  1313.   if ((len = endring - rs) >= LINESIZ)
  1314.     bcopy(rs, text, LINESIZ);
  1315.   else {
  1316.     bcopy(rs, text, len);
  1317.     bcopy(ring, text + len, LINESIZ - len);
  1318.   }
  1319.   if (++rs == endring)
  1320.     rs = ring;
  1321.   text[LINESIZ] = '\r';
  1322.   text[LINESIZ + 1] = '\n';
  1323.   (void) sendto(s, text, sizeof(text), 0, &sa, sizeof(sa));
  1324.  
  1325.   return 0;
  1326. }
  1327.  
  1328. /*
  1329.  * Return a machine readable date and time, in the form of the
  1330.  * number of seconds since midnight, Jan 1, 1900.  Since gettimeofday
  1331.  * returns the number of seconds since midnight, Jan 1, 1970,
  1332.  * we must add 2208988800 seconds to this figure to make up for
  1333.  * some seventy years Bell Labs was asleep.
  1334.  */
  1335.  
  1336. long
  1337. machtime(void)
  1338. {
  1339.   struct timeval tv;
  1340.  
  1341.   if (gettimeofday(&tv, (struct timezone *)0) < 0) {
  1342.     /* fprintf(stderr, "Unable to get time of day\n"); */
  1343.     return (0L);
  1344.   }
  1345.   return (htonl((long)tv.tv_sec + 2208988800));
  1346. }
  1347.  
  1348. int 
  1349. machtime_stream(void *SocketBase, int s, struct servtab *sep)
  1350. {
  1351.   long result;
  1352.  
  1353.   result = machtime();
  1354.   (void) send(s, (char *) &result, sizeof(result), 0);
  1355.  
  1356.   return 0;
  1357. }
  1358.  
  1359. machtime_dg(void *SocketBase, int s, struct servtab *sep)
  1360. {
  1361.   long result;
  1362.   struct sockaddr sa;
  1363.   long size;
  1364.  
  1365.   size = sizeof(sa);
  1366.   if (recvfrom(s, (char *)&result, sizeof(result), 0, &sa, &size) < 0)
  1367.     return 0;
  1368.   result = machtime();
  1369.   (void) sendto(s, (char *) &result, sizeof(result), 0, &sa, sizeof(sa));
  1370.  
  1371.   return 0;
  1372. }
  1373.  
  1374. /* Return human-readable time of day */
  1375. int
  1376. daytime_stream(void *SocketBase, int s, struct servtab *sep)
  1377. {
  1378.   char buffer[256];
  1379.   time_t time(), clock;
  1380.   char *ctime();
  1381.   
  1382.   clock = time((time_t *) 0);
  1383.   
  1384.   (void) strncpy(buffer, ctime(&clock), 24);   buffer[24] = '\0';
  1385.   (void) strcat(buffer, "\r\n");
  1386.   (void) send(s, buffer, strlen(buffer), 0);
  1387.   return 0;
  1388. }
  1389.  
  1390. /* Return human-readable time of day */
  1391. int
  1392. daytime_dg(void *SocketBase, int s, struct servtab *sep)
  1393. {
  1394.   char buffer[256];
  1395.   time_t time(), clock;
  1396.   struct sockaddr sa;
  1397.   long size;
  1398.  
  1399.   clock = time((time_t *) 0);
  1400.  
  1401.   size = sizeof(sa);
  1402.   if (recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size) < 0)
  1403.     return 0;
  1404.  
  1405.   (void) strncpy(buffer, ctime(&clock), 24);   buffer[24] = '\0';
  1406.   (void) strcat(buffer, "\r\n");
  1407.   (void) sendto(s, buffer, strlen(buffer), 0, &sa, sizeof(sa));
  1408.   return 0;
  1409. }
  1410.  
  1411. /*
  1412.  * Internal server stub 
  1413.  */
  1414. LONG SAVEDS start_builtin(void)
  1415. {
  1416.   struct Process *me = (struct Process *)FindTask(0L);
  1417.   struct DaemonMessage *dm = (struct DaemonMessage *)me->pr_ExitData;
  1418.   LONG retval = DERR_LIB; 
  1419.   void *SocketBase;
  1420.  
  1421.   if (SocketBase = OpenLibrary("bsdsocket.library", 2L)) {
  1422.     struct servtab *sep = (struct servtab *)dm->dm_Retval;
  1423.     int s = ObtainSocket(dm->dm_Id, AF_INET, sep->se_socktype, 0);
  1424.     if (s != -1) {
  1425.       dm->dm_Id = -1;
  1426.       retval = (*sep->se_bi->bi_fn)(SocketBase, s, sep);
  1427.     } else {
  1428.       retval = DERR_OBTAIN;
  1429.     }
  1430.     CloseLibrary(SocketBase);
  1431.   } 
  1432.  
  1433.   return retval;
  1434. }
  1435.  
  1436. /* 
  1437.  * setproctitle:
  1438.  *      set the process title
  1439.  */
  1440. void
  1441. setproctitle(char *a, int s)
  1442. {
  1443. #ifdef notyet
  1444.   int size;
  1445.   register char *cp;
  1446.   struct sockaddr_in sin;
  1447.   char buf[80];
  1448.   struct CSource csbuf;
  1449.   
  1450.   csbuf.CS_Buffer = buf;
  1451.   csbuf.CS_Length = sizeof(buf) - 1;
  1452.   csbuf.CS_CurChr = 0;
  1453.  
  1454.   size = sizeof(sin);
  1455.   if (getpeername(s, (struct sockaddr *)&sin, &size) == 0) {
  1456.     struct MemList ml, *nml;
  1457.  
  1458.     (void) csprintf(csbuf, "%s [%s]", a, inet_ntoa(sin.sin_addr)); 
  1459.  
  1460.     ml.ml_NumEntries = 1;
  1461.     ml.ml_ME[0].me_Reqs = MEMF_PUBLIC;
  1462.     ml.ml_ME[0].me_Length = csbuf.CS_CurChr + 1;
  1463.  
  1464.     /* A memlist entry is needed for automatic resource deallocation */
  1465.     if ((LONG)(nml = AllocEntry(&ml)) > 0) {
  1466.       struct Task *me = FindTask(NULL);
  1467.  
  1468.       cp = nml->ml_ME[1].me_Addr;
  1469.       buf[csbuf.CS_CurChr] = '\0';
  1470.       strcpy(cp, buf);
  1471.  
  1472.       /* Old name is pointer to se_service, so there is no need to free it */
  1473.       me->tc_Node.ln_Name = cp;
  1474.       Forbid();
  1475.       AddHead(&me->tc_MemEntry, nml);
  1476.       Permit();
  1477.     }
  1478.   }
  1479. #endif
  1480. }
  1481.  
  1482. /* 
  1483.  * proctitle:
  1484.  *     allocate a new process title 
  1485.  */
  1486. UBYTE *
  1487. proctitle(char *a, int s)
  1488. {
  1489.   long size;
  1490.   struct sockaddr_in sin;
  1491.   register char *cp;
  1492.   char buf[80];
  1493.   struct CSource csbuf;
  1494.   
  1495.   csbuf.CS_Buffer = buf;
  1496.   csbuf.CS_Length = sizeof(buf) - 1;
  1497.   csbuf.CS_CurChr = 0;
  1498.  
  1499.   size = sizeof(sin);
  1500.   if (getpeername(s, (struct sockaddr *)&sin, &size) == 0) {
  1501.     (void) csprintf(&csbuf, "%s [%s]", a, inet_ntoa(sin.sin_addr)); 
  1502.   } else {
  1503.     (void) csprintf(&csbuf, "%s", a); 
  1504.   }
  1505.   if (cp = AllocVec(csbuf.CS_CurChr + 1, MEMF_PUBLIC)) {
  1506.     buf[csbuf.CS_CurChr] = '\0';
  1507.     strcpy(cp, buf);
  1508.   }
  1509.   return cp;
  1510. }
  1511.  
  1512. #if __SASC
  1513. #define SysBase (*(struct ExecBase**)4)
  1514. /* 
  1515.  * Amiga process catcher
  1516.  */
  1517. ASM VOID
  1518. exitcode(REG(d0) LONG status, REG(d1) LONG exitmessage)
  1519. {
  1520.   ((struct DaemonMessage *)exitmessage)->dm_Retval = status;
  1521.   ReplyMsg((struct Message *)exitmessage);
  1522. }
  1523.  
  1524. void
  1525. exitcode_end(void)
  1526. {
  1527. }
  1528. #undef SysBase
  1529.  
  1530. #define exitcode_len (((char *)exitcode_end)-((char *)exitcode))
  1531. #else
  1532. #error Unsupported compiler
  1533. #endif
  1534.  
  1535. void *WindowPtr = NULL;
  1536.  
  1537. /* 
  1538.  * Initialize Amiga Specific Features
  1539.  */
  1540. void 
  1541. amigainit(void)
  1542. {
  1543.   struct DaemonPort *dp, *dpo;
  1544.   BYTE msgbit;
  1545.   struct Process *me = (struct Process *)FindTask(NULL);
  1546.   int old_is_alive = 0;
  1547.  
  1548.   atexit(amigadeinit);
  1549.  
  1550.   /* Remove requesters */
  1551.   WindowPtr = me->pr_WindowPtr;
  1552.   me->pr_WindowPtr = (void *)-1L;
  1553.  
  1554.   if ((msgbit = AllocSignal(-1)) == -1) {
  1555.     (void)fprintf(stderr, "inetd: no free signals\n");
  1556.     exit(2);
  1557.   }
  1558.  
  1559.   /* Allocate a global port for DaemonMessages */
  1560.   if (dp = AllocVec(sizeof(*dp) + exitcode_len + sizeof(DAEMONPORTNAME),
  1561.             MEMF_CLEAR|MEMF_PUBLIC)) {
  1562.     dp->dp_Port.mp_Node.ln_Type = NT_MSGPORT;
  1563.     dp->dp_Port.mp_SigTask = me;
  1564.     dp->dp_Port.mp_Flags = PA_SIGNAL;
  1565.     dp->dp_Port.mp_SigBit = msgbit;
  1566.     memcpy(dp->dp_ExitCode = (char *)(dp + 1), exitcode, exitcode_len);
  1567.     memcpy(dp->dp_Port.mp_Node.ln_Name = exitcode_len + (UBYTE *)(dp + 1),
  1568.        DAEMONPORTNAME, sizeof(DAEMONPORTNAME));
  1569.     /* Flush copied function */
  1570.     CacheClearE(dp->dp_ExitCode, exitcode_len, CACRF_ClearI);
  1571.   }
  1572.  
  1573.   Forbid();
  1574.  
  1575.   dpo = (struct DaemonPort*)FindPort(DAEMONPORTNAME);
  1576.   if (!dpo) {
  1577.     if (dp) AddPort(dp);
  1578.   } else {
  1579.     FreeVec(dp);
  1580.     dp = dpo;
  1581.     if (dpo->dp_Port.mp_SigTask == NULL) {
  1582.       dpo->dp_Port.mp_SigTask = me;
  1583.       dpo->dp_Port.mp_SigBit = msgbit;
  1584.       dpo->dp_Port.mp_Flags = PA_SIGNAL;
  1585.       SetSignal(1 << msgbit, 1 << msgbit); /* check old messages */
  1586.     } else {
  1587.       old_is_alive = 1;
  1588.     }
  1589.   }
  1590.   Permit();
  1591.  
  1592.   if (old_is_alive || !dp) {
  1593.     FreeSignal(msgbit);
  1594.     (void)fprintf(stderr, old_is_alive ? 
  1595.           "inetd: already exists\n" :
  1596.           "inetd: memory exhausted\n");
  1597.     exit(2);
  1598.   }
  1599.  
  1600.   dport = dp;
  1601.  
  1602.   if (!(tport = CreateMsgPort())) {
  1603.     (void)fprintf(stderr, "inetd: could not create message port\n");
  1604.     exit(2);
  1605.   }
  1606.   if (!(tmsg = CreateIORequest(tport, sizeof(*tmsg)))){
  1607.     (void)fprintf(stderr, "inetd: could not create timer message\n");
  1608.     exit(2);
  1609.   }
  1610.  
  1611.   tmsg->tr_node.io_Message.mn_Node.ln_Type = NT_UNKNOWN; 
  1612.  
  1613.   if (OpenDevice(TIMERNAME, UNIT_MICROHZ, 
  1614.          (struct IORequest *)tmsg, 0)) {
  1615.     (void)fprintf(stderr, "inetd: could not open %s\n", TIMERNAME);
  1616.     exit(2);
  1617.   }
  1618.   timer_is_open = 1;
  1619. }
  1620.  
  1621. /* 
  1622.  * Deinitialize Amiga Specific stuff
  1623.  */
  1624. void
  1625. amigadeinit(void)
  1626. {
  1627.   struct Process *me = (struct Process *)FindTask(NULL);
  1628.  
  1629.   /* Resume requesters for this process */
  1630.   me->pr_WindowPtr = WindowPtr;
  1631.  
  1632.   if (tmsg && timer_is_open) {
  1633.     if (tmsg->tr_node.io_Message.mn_Node.ln_Type != NT_UNKNOWN 
  1634.     && !CheckIO(tmsg)) {
  1635.       AbortIO(tmsg);
  1636.       WaitIO(tmsg);
  1637.     }
  1638.   }
  1639.   if (timer_is_open) {
  1640.     CloseDevice(tmsg);
  1641.     timer_is_open = 0;
  1642.   }
  1643.   if (tmsg) {
  1644.     DeleteIORequest(tmsg);
  1645.   }
  1646.   if (tport) {
  1647.     DeleteMsgPort(tport);
  1648.   }
  1649.  
  1650.   if (dport) {
  1651.     BYTE sigbit;
  1652.     int i;
  1653.  
  1654.     /* Try to kill all our builtin children */
  1655.     for (i = builtins_started - 1; i >= 0; i--)
  1656.       Signal((struct Task*)ptable[i], SIGBREAKF_CTRL_C);
  1657.     /* Close all sockets */
  1658.     for (i = NOFILE - 1; i >= 0; i--) {
  1659.       CloseSocket(i);
  1660.     }
  1661.     /* Wait until all childs are terminated */
  1662.     while (builtins_started > 0) {
  1663.       WaitPort(dport);
  1664.       reapchild();
  1665.     }
  1666.  
  1667.     Forbid();
  1668.     sigbit = dport->dp_Port.mp_SigBit;
  1669.     dport->dp_Port.mp_Flags = PA_IGNORE;
  1670.     dport->dp_Port.mp_SigBit = (UBYTE)-1; /* braindead */
  1671.     dport->dp_Port.mp_SigTask = NULL;
  1672.     FreeSignal(sigbit);
  1673.     Permit();
  1674.   }
  1675. }
  1676.  
  1677. /*
  1678.  * Generic printing functions 
  1679.  */
  1680. void ASM 
  1681. stuffchar(REG(d0) char ch, REG(a3) struct CSource * sc)
  1682. {
  1683.   if (sc->CS_CurChr < sc->CS_Length 
  1684.       && (sc->CS_Buffer[sc->CS_CurChr] = ch))
  1685.     sc->CS_CurChr++;
  1686. }
  1687.  
  1688. static ULONG
  1689. csprintf(struct CSource *buf, const char *fmt, ...)
  1690. {
  1691.   ULONG start = buf->CS_CurChr;
  1692.   va_list ap;
  1693.  
  1694.   if (buf->CS_Length && buf->CS_CurChr < buf->CS_Length) {
  1695.     va_start(ap, fmt);
  1696.     RawDoFmt((STRPTR)fmt, ap, stuffchar, buf);
  1697.     va_end(ap);
  1698.     
  1699.     if (buf->CS_CurChr == buf->CS_Length) {
  1700.       buf->CS_CurChr--;            /* must NUL terminate */
  1701.     }      
  1702.     buf->CS_Buffer[buf->CS_CurChr] = '\0';
  1703.  
  1704.     return buf->CS_CurChr - start;
  1705.   } else {
  1706.     /* A pathological case */
  1707.     return 0;
  1708.   }
  1709. }
  1710.